Operators এর ব্যবহার

RxJava-তে Operators হল শক্তিশালী টুল, যা ডাটা স্ট্রিমে বিভিন্ন রূপান্তর, ফিল্টারিং, কম্বিনেশন, এবং আরও অনেক কিছু করার জন্য ব্যবহৃত হয়।

নিচে RxJava-এর Operators এবং তাদের ব্যবহার উদাহরণসহ ব্যাখ্যা করা হয়েছে:

RxJava Operators:

1. Transformational Operators

ডাটা ট্রান্সফর্ম বা পরিবর্তনের জন্য ব্যবহৃত হয়।

map() উদাহরণ:

Observable.just(1, 2, 3)
    .map(num -> num * 10) // প্রতিটি সংখ্যা ১০ দিয়ে গুণ
    .subscribe(result -> System.out.println("Transformed: " + result));

আউটপুট:

Transformed: 10
Transformed: 20
Transformed: 30

2. Filtering Operators

ডাটা ফিল্টার করার জন্য ব্যবহৃত হয়।

filter() উদাহরণ:

Observable.just(1, 2, 3, 4, 5)
    .filter(num -> num % 2 == 0) // শুধুমাত্র জোড় সংখ্যা
    .subscribe(result -> System.out.println("Filtered: " + result));

আউটপুট:

Filtered: 2
Filtered: 4

3. Combining Operators

একাধিক Observable-কে একত্রিত করার জন্য ব্যবহৃত হয়।

zip() উদাহরণ:

Observable<Integer> numbers = Observable.just(1, 2, 3);
Observable<String> words = Observable.just("One", "Two", "Three");

Observable.zip(numbers, words, (num, word) -> num + " - " + word)
    .subscribe(result -> System.out.println("Combined: " + result));

আউটপুট:

Combined: 1 - One
Combined: 2 - Two
Combined: 3 - Three

4. Error Handling Operators

Error ম্যানেজ করার জন্য ব্যবহৃত হয়।

onErrorReturn() উদাহরণ:

Observable<Integer> observable = Observable.create(emitter -> {
    emitter.onNext(1);
    emitter.onNext(2);
    emitter.onError(new RuntimeException("Error occurred!"));
});

observable
    .onErrorReturn(e -> -1) // এরর হলে -1 প্রদান
    .subscribe(
        item -> System.out.println("Received: " + item),
        throwable -> System.out.println("Error: " + throwable),
        () -> System.out.println("Completed!")
    );

আউটপুট:

Received: 1
Received: 2
Received: -1

5. Utility Operators

Observable-এ বিভিন্ন utility কাজের জন্য ব্যবহৃত হয়।

doOnNext() উদাহরণ:

Observable.just("A", "B", "C")
    .doOnNext(item -> System.out.println("Processing: " + item)) // প্রসেসিং লগ
    .subscribe(result -> System.out.println("Received: " + result));

আউটপুট:

Processing: A
Received: A
Processing: B
Received: B
Processing: C
Received: C

সংক্ষেপে RxJava Operators:

• Transform: map(), flatMap(), concatMap()
• Filter: filter(), take(), skip()
• Combine: merge(), zip(), concat()
• Error Handling: onErrorReturn(), retry()
• Utility: doOnNext(), delay(), timeout()

RxJava-তে Operators ব্যবহার করে ডাটা স্ট্রিম প্রসেসিং আরও সহজ এবং শক্তিশালী করা যায়।

RxJava Operators হলো ফাংশনাল কম্পোনেন্ট, যা Reactive Programming এর মূল শক্তি প্রদান করে। এগুলো ডেটা স্ট্রিম প্রসেসিং, ম্যানিপুলেশন এবং ট্রান্সফরমেশনের জন্য ব্যবহৃত হয়। এককথায়, Operators ব্যবহার করে আপনি ডেটা স্ট্রিমে বিভিন্ন প্রকার কাজ করতে পারেন, যেমন: ডেটা ফিল্টার করা, ম্যাপ করা, একাধিক স্ট্রিমকে মিশ্রিত করা, ইত্যাদি।

Operators কেন প্রয়োজন?

1. ডেটা প্রসেসিং সহজ করা:
   Operators ডেটা প্রসেসিং ও ম্যানিপুলেশন সহজ এবং কার্যকর করে।
   উদাহরণস্বরূপ, একটি ডেটা স্ট্রিমকে ফিল্টার করা, ডেটা পরিবর্তন করা, অথবা গ্রুপিং করা।
2. Declarative Programming:
   Operators ব্যবহার করে কোড আরও পাঠযোগ্য এবং পরিষ্কার করা যায়। এটি ডেটা ফ্লো বোঝা সহজ করে।
3. Chaining & Composition:
   Operators এর সাহায্যে একাধিক অপারেশন একসাথে চেইন করা যায়, যা কমপ্লেক্স প্রসেসিং লজিক লিখতে সাহায্য করে।
4. Asynchronous Task Handling:
   ডেটা স্ট্রিমের অপারেশনগুলো asynchronous ভাবে পরিচালনা করার জন্য Operators অপরিহার্য।
5. Error Handling:
   ডেটা প্রসেসিং এর সময় সম্ভাব্য ত্রুটি (error) গুলো সহজে হ্যান্ডেল করা যায়।

RxJava এর Operators এর ধরন

RxJava বিভিন্ন ধরণের Operators সরবরাহ করে। নিচে কিছু প্রধান ক্যাটেগরি এবং তাদের উদাহরণ দেওয়া হলো:

১. Creating Operators

নতুন Observable তৈরি করতে ব্যবহৃত হয়।

• just(): একটি স্ট্যাটিক ডেটা স্ট্রিম তৈরি করে।
• fromIterable(): একটি Iterable থেকে Observable তৈরি করে।
• create(): কাস্টম Observable তৈরি করতে ব্যবহৃত।

উদাহরণ:

Observable<String> observable = Observable.just("Hello", "RxJava");
observable.subscribe(System.out::println);

২. Transforming Operators

ডেটা স্ট্রিমের ডেটাকে পরিবর্তন করে।

• map(): ডেটা স্ট্রিমের প্রতিটি আইটেমকে ট্রান্সফর্ম করে।
• flatMap(): একটি আইটেম থেকে একাধিক Observable তৈরি করে।
• scan(): পূর্ববর্তী এবং বর্তমান আইটেমের উপর ভিত্তি করে একটি অপারেশন চালায়।

উদাহরণ:

Observable.just(1, 2, 3, 4)
    .map(i -> i * 2) // প্রতিটি আইটেমকে দ্বিগুণ করে
    .subscribe(System.out::println);

৩. Filtering Operators

ডেটা স্ট্রিম থেকে নির্দিষ্ট আইটেম নির্বাচন বা বাদ দিতে ব্যবহৃত।

• filter(): নির্দিষ্ট শর্ত পূরণ না করলে আইটেম ফিল্টার করে।
• take(n): শুরুর n টি আইটেম গ্রহণ করে।
• skip(n): প্রথম n টি আইটেম বাদ দেয়।

উদাহরণ:

Observable.just(1, 2, 3, 4, 5)
    .filter(i -> i % 2 == 0) // শুধুমাত্র জোড় সংখ্যা রাখে
    .subscribe(System.out::println);

৪. Combining Operators

একাধিক Observable এর ডেটা স্ট্রিমকে একত্রিত করতে ব্যবহৃত।

• merge(): একাধিক Observable কে একত্রিত করে।
• zip(): দুই বা ততোধিক Observable এর ডেটাকে একত্রিত করে।
• concat(): একাধিক Observable সিরিয়ালি একত্রিত করে।

উদাহরণ:

Observable<String> obs1 = Observable.just("A", "B");
Observable<String> obs2 = Observable.just("1", "2");

Observable.zip(obs1, obs2, (s1, s2) -> s1 + s2)
    .subscribe(System.out::println);

আউটপুট:

A1
B2

৫. Error Handling Operators

ডেটা স্ট্রিমে error হ্যান্ডলিং করতে ব্যবহৃত।

• onErrorReturn(): ত্রুটি ঘটলে একটি নির্দিষ্ট ডেটা ফেরত দেয়।
• retry(): ত্রুটি ঘটলে পুনরায় চেষ্টা করে।
• onErrorResumeNext(): একটি নতুন Observable এ স্যুইচ করে।

উদাহরণ:

Observable.just(1, 0)
    .map(i -> 10 / i) // এখানে divide by zero exception ঘটবে
    .onErrorReturn(e -> -1) // ত্রুটি ঘটলে -1 ফেরত দিবে
    .subscribe(System.out::println);

৬. Utility Operators

ডেটা স্ট্রিমের কার্যপ্রবাহ পর্যবেক্ষণ করতে ব্যবহৃত।

• delay(): ডেটা স্ট্রিমের প্রসেসিং বিলম্বিত করে।
• doOnNext(): প্রতিটি আইটেম প্রক্রিয়ার সময় কার্যকলাপ সম্পন্ন করে।
• timeout(): নির্ধারিত সময়ের মধ্যে ডেটা স্ট্রিমের প্রতিক্রিয়া না পেলে error তৈরি করে।

উদাহরণ:

Observable.just("Hello", "RxJava")
    .doOnNext(item -> System.out.println("Processing: " + item))
    .subscribe(System.out::println);

Operators এর সুবিধা

1. Simplifies Complex Logic:
   কমপ্লেক্স ডেটা স্ট্রিম ম্যানিপুলেশন সহজ এবং দ্রুত করে।
2. Reusable:
   Operators পুনরায় ব্যবহারযোগ্য, তাই কোড modular হয়।
3. Concurrency Handling:
   ডেটা স্ট্রিমের concurrency পরিচালনা আরও সহজ করে।
4. Declarative and Clean Code:
   ডেটা স্ট্রিমে সরাসরি অপারেশনগুলো ডিক্লেয়ার করে কোড আরও পরিষ্কার করা যায়।

RxJava এর Operators হল এর আসল শক্তি। এগুলো ব্যবহার করে asynchronous এবং event-driven প্রোগ্রামিং অনেক সহজ এবং কার্যকর হয়ে ওঠে।

RxJava-তে অপারেটর হলো ডেটা স্ট্রিম ম্যানিপুলেট করার টুল। এগুলো ডেটা প্রসেসিং সহজ করে এবং রিয়েক্টিভ প্রোগ্রামিংয়ে অনেক ক্ষমতা যোগ করে। নিচে কিছু গুরুত্বপূর্ণ অপারেটরের ব্যাখ্যা এবং উদাহরণ দেয়া হলো।

1. map অপারেটর

• ব্যবহার: একটি ডেটাকে অন্য ফর্মে রূপান্তর করতে।
• উদাহরণ: একটি সংখ্যা ডাবল করা।

import io.reactivex.rxjava3.core.Observable;

public class MapExample {
    public static void main(String[] args) {
        Observable<Integer> numbers = Observable.just(1, 2, 3, 4, 5);

        numbers.map(number -> number * 2)
               .subscribe(result -> System.out.println("Mapped value: " + result));
    }
}

আউটপুট:

Mapped value: 2  
Mapped value: 4  
Mapped value: 6  
Mapped value: 8  
Mapped value: 10  

2. flatMap অপারেটর

• ব্যবহার: এক Observable কে আরও একাধিক Observable-এ রূপান্তর করতে।
• উদাহরণ: একটি ডেটা লিস্ট তৈরি করা এবং তা ফ্ল্যাট করা।

import io.reactivex.rxjava3.core.Observable;

public class FlatMapExample {
    public static void main(String[] args) {
        Observable<String> users = Observable.just("User1", "User2");

        users.flatMap(user -> Observable.just(user + " - Data1", user + " - Data2"))
             .subscribe(data -> System.out.println("FlatMapped value: " + data));
    }
}

আউটপুট:

FlatMapped value: User1 - Data1  
FlatMapped value: User1 - Data2  
FlatMapped value: User2 - Data1  
FlatMapped value: User2 - Data2  

3. filter অপারেটর

• ব্যবহার: নির্দিষ্ট শর্ত অনুযায়ী ডেটা ফিল্টার করতে।
• উদাহরণ: শুধু জোড় সংখ্যাগুলো বের করা।

import io.reactivex.rxjava3.core.Observable;

public class FilterExample {
    public static void main(String[] args) {
        Observable<Integer> numbers = Observable.just(1, 2, 3, 4, 5, 6);

        numbers.filter(number -> number % 2 == 0)
               .subscribe(result -> System.out.println("Filtered value: " + result));
    }
}

আউটপুট:

Filtered value: 2  
Filtered value: 4  
Filtered value: 6  

4. reduce অপারেটর

• ব্যবহার: ডেটা স্ট্রিমকে একক ফলাফলে কমিয়ে আনতে।
• উদাহরণ: সব সংখ্যার যোগফল বের করা।

import io.reactivex.rxjava3.core.Observable;

public class ReduceExample {
    public static void main(String[] args) {
        Observable<Integer> numbers = Observable.just(1, 2, 3, 4, 5);

        numbers.reduce((sum, number) -> sum + number)
               .subscribe(result -> System.out.println("Reduced value: " + result));
    }
}

আউটপুট:

Reduced value: 15  

সব অপারেটরের ব্যবহার সংক্ষেপে

সংক্ষিপ্ত টিপস:

1. map এবং flatMap খুবই শক্তিশালী, তবে ভুল ব্যবহারে কমপ্লেক্সিটি বাড়তে পারে।
2. filter ব্যবহার করে শুধুমাত্র প্রয়োজনীয় ডেটা স্ট্রিমে রাখা সহজ।
3. reduce বড় ডেটা প্রসেসিংয়ের জন্য ভালো তবে এটি শুধুমাত্র Finite Observable-এর জন্য কাজ করে।

আপনার যদি এই বিষয়ে আরও কিছু জানার প্রয়োজন হয়, বলুন! 😊

RxJava-তে Transformation, Filtering, এবং Combining Operators ব্যবহার করে আমরা ডেটা স্ট্রিমকে রূপান্তর করতে, ফিল্টার করতে এবং একাধিক স্ট্রিমকে একত্রিত করতে পারি। এরা functional programming স্টাইল ব্যবহার করে asynchronous ডেটা স্ট্রিম প্রক্রিয়াকরণ সহজ করে।

1. Transformation Operators

Transformation Operators ডেটা স্ট্রিমের উপাদানগুলোকে রূপান্তর করে।

(a) map

একটি উপাদানকে অন্য ফর্ম্যাটে রূপান্তরিত করতে ব্যবহৃত হয়।

Observable.just(1, 2, 3, 4)
    .map(item -> item * 2) // প্রতিটি উপাদানকে ২ দিয়ে গুণ
    .subscribe(item -> System.out.println("Transformed: " + item));

Output:

Transformed: 2
Transformed: 4
Transformed: 6
Transformed: 8

(b) flatMap

একটি উপাদানকে নতুন একটি Observable-এ রূপান্তরিত করে এবং তাদের একত্রিত করে।

Observable.just("Hello", "World")
    .flatMap(item -> Observable.just(item.toUpperCase()))
    .subscribe(item -> System.out.println("FlatMapped: " + item));

Output:

FlatMapped: HELLO
FlatMapped: WORLD

(c) scan

পূর্বের উপাদানের সাথে বর্তমান উপাদানের accumulator function প্রয়োগ করে।

Observable.just(1, 2, 3, 4)
    .scan((total, next) -> total + next)
    .subscribe(item -> System.out.println("Accumulated: " + item));

Output:

Accumulated: 1
Accumulated: 3
Accumulated: 6
Accumulated: 10

2. Filtering Operators

Filtering Operators ব্যবহার করে স্ট্রিম থেকে নির্দিষ্ট উপাদান ফিল্টার করা যায়।

(a) filter

নির্দিষ্ট শর্ত পূরণ করে এমন উপাদানগুলো রাখতে ব্যবহার হয়।

Observable.just(1, 2, 3, 4, 5)
    .filter(item -> item % 2 == 0) // জোড় সংখ্যা নির্বাচন
    .subscribe(item -> System.out.println("Filtered: " + item));

Output:

Filtered: 2
Filtered: 4

(b) take

প্রথম N উপাদান নিতে ব্যবহৃত হয়।

Observable.just(1, 2, 3, 4, 5)
    .take(3)
    .subscribe(item -> System.out.println("Taken: " + item));

Output:

Taken: 1
Taken: 2
Taken: 3

(c) distinct

একই ডেটা একাধিকবার আসা থেকে প্রতিরোধ করে।

Observable.just(1, 2, 2, 3, 4, 4, 5)
    .distinct()
    .subscribe(item -> System.out.println("Distinct: " + item));

Output:

Distinct: 1
Distinct: 2
Distinct: 3
Distinct: 4
Distinct: 5

3. Combining Operators

Combining Operators বিভিন্ন Observable-কে একত্রিত করতে ব্যবহৃত হয়।

(a) merge

দুটি Observable একত্রিত করে এবং parallel ডেটা emission পরিচালনা করে।

Observable<String> observable1 = Observable.just("A", "B");
Observable<String> observable2 = Observable.just("C", "D");

Observable.merge(observable1, observable2)
    .subscribe(item -> System.out.println("Merged: " + item));

Output:

Merged: A
Merged: B
Merged: C
Merged: D

(b) zip

দুটি Observable-এর emission একত্রিত করে একটি নতুন emission তৈরি করে।

Observable<String> observable1 = Observable.just("X", "Y");
Observable<Integer> observable2 = Observable.just(1, 2);

Observable.zip(observable1, observable2, (item1, item2) -> item1 + item2)
    .subscribe(item -> System.out.println("Zipped: " + item));

Output:

Zipped: X1
Zipped: Y2

(c) combineLatest

প্রতিটি Observable থেকে শেষ emitted value গ্রহণ করে তাদের একত্রিত করে।

Observable<String> observable1 = Observable.just("A", "B");
Observable<Integer> observable2 = Observable.just(1, 2, 3);

Observable.combineLatest(
    observable1,
    observable2,
    (item1, item2) -> item1 + item2
).subscribe(item -> System.out.println("Combined: " + item));

Output:

Combined: B1
Combined: B2
Combined: B3

উপসংহার

• Transformation Operators: ডেটা পরিবর্তন করতে ব্যবহৃত হয়।
• Filtering Operators: স্ট্রিম থেকে নির্দিষ্ট ডেটা বেছে নিতে সাহায্য করে।
• Combining Operators: একাধিক Observable থেকে ডেটা একত্রিত করতে ব্যবহৃত হয়।

এই Operators ব্যবহার করে asynchronous এবং event-driven programming আরও শক্তিশালী এবং কার্যকরী করা যায়।

RxJava-র Operators হল core tool যা asynchronous এবং event-driven data streams পরিচালনা এবং রূপান্তর করতে সাহায্য করে। এগুলো Observable-এ বিভিন্ন ধরনের পরিবর্তন এবং প্রসেসিং করার জন্য ব্যবহার করা হয়।

1. Creation Operators

Creation Operators নতুন Observables তৈরি করতে সাহায্য করে।

উদাহরণ: just, fromArray, create

import io.reactivex.Observable;

public class CreationOperatorsExample {
    public static void main(String[] args) {
        // Just Operator
        Observable<String> justObservable = Observable.just("Hello", "RxJava");
        justObservable.subscribe(item -> System.out.println("Received: " + item));

        // FromArray Operator
        Observable<Integer> fromArrayObservable = Observable.fromArray(1, 2, 3, 4, 5);
        fromArrayObservable.subscribe(item -> System.out.println("Received: " + item));
    }
}

আউটপুট:

Received: Hello
Received: RxJava
Received: 1
Received: 2
Received: 3
Received: 4
Received: 5

2. Transformational Operators

ডাটা স্ট্রিমকে পরিবর্তন করার জন্য ব্যবহার হয়।

উদাহরণ: map, flatMap

import io.reactivex.Observable;

public class TransformOperatorsExample {
    public static void main(String[] args) {
        // Map Operator
        Observable<Integer> mapObservable = Observable.just(1, 2, 3, 4, 5)
            .map(item -> item * 2); // প্রতিটি element কে গুণ করা হয়
        mapObservable.subscribe(item -> System.out.println("Mapped: " + item));

        // FlatMap Operator
        Observable<String> flatMapObservable = Observable.just("A", "B", "C")
            .flatMap(item -> Observable.just(item + "1", item + "2"));
        flatMapObservable.subscribe(item -> System.out.println("FlatMapped: " + item));
    }
}

আউটপুট:

Mapped: 2
Mapped: 4
Mapped: 6
Mapped: 8
Mapped: 10
FlatMapped: A1
FlatMapped: A2
FlatMapped: B1
FlatMapped: B2
FlatMapped: C1
FlatMapped: C2

3. Filtering Operators

ডাটা ফিল্টার করার জন্য ব্যবহার হয়।

উদাহরণ: filter, take, distinct

import io.reactivex.Observable;

public class FilterOperatorsExample {
    public static void main(String[] args) {
        // Filter Operator
        Observable<Integer> filterObservable = Observable.just(1, 2, 3, 4, 5, 6)
            .filter(item -> item % 2 == 0); // শুধুমাত্র even number রাখে
        filterObservable.subscribe(item -> System.out.println("Filtered: " + item));

        // Distinct Operator
        Observable<Integer> distinctObservable = Observable.just(1, 2, 2, 3, 4, 4, 5)
            .distinct(); // ডুপ্লিকেট সরিয়ে দেয়
        distinctObservable.subscribe(item -> System.out.println("Distinct: " + item));

        // Take Operator
        Observable<Integer> takeObservable = Observable.just(1, 2, 3, 4, 5)
            .take(3); // প্রথম ৩টি element নেয়
        takeObservable.subscribe(item -> System.out.println("Taken: " + item));
    }
}

আউটপুট:

Filtered: 2
Filtered: 4
Filtered: 6
Distinct: 1
Distinct: 2
Distinct: 3
Distinct: 4
Distinct: 5
Taken: 1
Taken: 2
Taken: 3

4. Combining Operators

বিভিন্ন Observable মিশ্রণ বা কম্বিনেশনের জন্য ব্যবহার হয়।

উদাহরণ: merge, zip, concat

import io.reactivex.Observable;

public class CombiningOperatorsExample {
    public static void main(String[] args) {
        // Merge Operator
        Observable<String> mergeObservable = Observable.merge(
            Observable.just("Hello"),
            Observable.just("World")
        );
        mergeObservable.subscribe(item -> System.out.println("Merged: " + item));

        // Zip Operator
        Observable<String> zipObservable = Observable.zip(
            Observable.just("A", "B", "C"),
            Observable.just("1", "2", "3"),
            (s1, s2) -> s1 + s2 // Combine করে
        );
        zipObservable.subscribe(item -> System.out.println("Zipped: " + item));

        // Concat Operator
        Observable<String> concatObservable = Observable.concat(
            Observable.just("First"),
            Observable.just("Second")
        );
        concatObservable.subscribe(item -> System.out.println("Concatenated: " + item));
    }
}

আউটপুট:

Merged: Hello
Merged: World
Zipped: A1
Zipped: B2
Zipped: C3
Concatenated: First
Concatenated: Second

5. Error Handling Operators

Error management-এর জন্য ব্যবহার হয়।

উদাহরণ: onErrorReturn, onErrorResumeNext

import io.reactivex.Observable;

public class ErrorHandlingExample {
    public static void main(String[] args) {
        // OnErrorReturn Operator
        Observable<Integer> onErrorReturnObservable = Observable.just(1, 2, 0, 4)
            .map(item -> 10 / item) // Division by zero exception
            .onErrorReturn(error -> -1); // Error হলে -1 রিটার্ন করবে
        onErrorReturnObservable.subscribe(
            item -> System.out.println("Received: " + item),
            error -> System.err.println("Error: " + error)
        );

        // OnErrorResumeNext Operator
        Observable<Integer> onErrorResumeNextObservable = Observable.just(1, 0, 3)
            .map(item -> 10 / item)
            .onErrorResumeNext(Observable.just(100, 200)); // Error হলে নতুন Observable
        onErrorResumeNextObservable.subscribe(item -> System.out.println("Received: " + item));
    }
}

আউটপুট:

Received: 10
Received: 5
Received: -1
Received: 10
Received: 100
Received: 200

6. Utility Operators

নির্ধারিত কাজ সম্পাদনের জন্য সহায়ক।

উদাহরণ: delay, doOnNext

import io.reactivex.Observable;
import java.util.concurrent.TimeUnit;

public class UtilityOperatorsExample {
    public static void main(String[] args) throws InterruptedException {
        // Delay Operator
        Observable.just("Delayed Hello")
            .delay(2, TimeUnit.SECONDS)
            .subscribe(item -> System.out.println(item));
        
        // DoOnNext Operator
        Observable<Integer> doOnNextObservable = Observable.just(1, 2, 3)
            .doOnNext(item -> System.out.println("Processing: " + item));
        doOnNextObservable.subscribe(item -> System.out.println("Received: " + item));

        Thread.sleep(3000); // Main thread sleep for delay output
    }
}

আউটপুট:

Processing: 1
Received: 1
Processing: 2
Received: 2
Processing: 3
Received: 3
Delayed Hello

উপসংহার

RxJava-এর Operators asynchronous এবং event-driven programming-এর জন্য একটি শক্তিশালী টুলসেট সরবরাহ করে। সঠিক Operators নির্বাচন করলে কাজ সহজ ও কার্যকর হয়। বাস্তব প্রয়োগে অপারেটরগুলির দক্ষ ব্যবহার critical।